Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@CHANGELOG.md`:
- Line 35: Update the headline "11 new tests" to match the enumerated breakdown
by changing it to "16 new tests" (since the list sums to 8 backend + 1 port + 1
adapter + 4 frontend PasteZone + 2 frontend LinkGrabberView = 16), or
alternatively adjust the per-section counts to total 11 if that was intended;
edit the changelog sentence containing "11 new tests" and ensure the numbers in
the parenthetical breakdown (the "8 backend (...) , 1 port ..., 1 adapter ..., 4
frontend PasteZone ..., 2 frontend LinkGrabberView ...") are consistent with the
headline.

In `@src-tauri/src/adapters/driven/plugin/extism_loader.rs`:
- Around line 424-445: The loop currently treats errors from
self.registry.function_exists(info.name(), "decrypt") as mere warnings and
ultimately returns DomainError::NotFound, which hides plugin probe failures;
change the logic in the decrypt lookup loop so that if function_exists returns
Err(e) you return Err(DomainError::PluginError(...)) (include info.name() and
the error e in the message) instead of continuing, while keeping the existing
behavior of calling self.registry.call_plugin_bytes(info.name(), "decrypt",
bytes) when function_exists is Ok(true); ensure any call_plugin_bytes errors are
still mapped to DomainError::PluginError as before.

In `@src-tauri/src/adapters/driving/tauri_ipc.rs`:
- Around line 1014-1016: Update the fallback message in the
AppError::Domain(DomainError::NotFound(_)) match arm in tauri_ipc.rs to include
the missing ".meta4" extension so users see the full list of supported container
formats; locate the match arm that currently returns "Install
vortex-mod-containers to import .dlc/.ccf/.rsdf/.metalink files" and add
".meta4" into that string (e.g., include ".meta4" among the extensions) so the
guidance is complete.

In `@src-tauri/src/application/commands/import_container.rs`:
- Around line 71-76: The collected URLs currently map from response.links ->
l.url and only check u.trim().is_empty(), leaving surrounding whitespace in the
stored strings; update the pipeline that builds urls (the mapping from
response.links and the variable urls) to trim each l.url (e.g., produce a
trimmed String) before collecting and then filter out empty trimmed strings so
urls contains clean, whitespace-free URLs for later resolve_batch.

In `@src-tauri/src/domain/ports/driven/plugin_loader.rs`:
- Around line 139-150: The docstring for container decryption is incorrect about
precedence—ExtismPluginLoader::decrypt_container() sorts enabled Container
plugins by name before probing, so the winner is the alphabetically-first
enabled container plugin, not the "first loaded"; update the comment on the
decrypt_container() port (referencing Container category and the decrypt
function) to state that enabled container plugins are tried in alphabetical
order by plugin name (or alternatively remove the name-sorting in
ExtismPluginLoader::decrypt_container() if you prefer true load-order
semantics)—make the doc and code behavior consistent and mention the exact
precedence rule used.

In `@src/views/LinkGrabberView/LinkGrabberView.tsx`:
- Around line 205-228: The current container import flow calls
invoke("link_import_container") and throws away result.packageId, only
aggregating result.urls into aggregatedUrls and calling resolveLinks({ urls:
aggregatedUrls }); Update this flow to carry the originating packageId through
the resolution/download pipeline: when handling the
invoke("link_import_container") response, push an object containing
result.packageId and result.urls (or map urls -> { url, packageId }) into the
aggregate instead of plain strings, then change resolveLinks (and downstream
download_start calls) to accept and propagate an optional packageId parameter so
that the server-side download_start can attach created download IDs to the
provided packageId; alternatively, defer creating the package on import and
create it when download IDs exist, but ensure either resolveLinks or
download_start accepts and forwards result.packageId (from
invoke("link_import_container")) so imported links are associated with the
package rather than creating empty packages.
- Around line 203-208: The code in LinkGrabberView.tsx currently calls
file.arrayBuffer() and builds bytes before sending to
invoke("link_import_container"), which allocates the entire file in memory; add
a pre-check on file.size against the backend container size limit (define a
constant e.g. CONTAINER_MAX_BYTES matching the backend cap) and reject oversized
files immediately (show an error/notification and return) before calling
file.arrayBuffer(); keep the rest of the flow (Uint8Array -> Array.from ->
invoke<ImportContainerResult>) unchanged so only files within the limit are read
into memory.

---

Nitpick comments:
In `@src/types/container.ts`:
- Around line 1-5: ImportContainerResult currently types the field format as
string which prevents exhaustiveness checks; change format in the
ImportContainerResult interface to a closed string union matching the backend’s
allowed container formats (replace format: string with format: 'X' | 'Y' | ...),
update any code that constructs or switches on ImportContainerResult.format to
use the new union values, and adjust tests/typeguards to handle the explicit
variants so typos become compile-time errors; reference the
ImportContainerResult interface and any switch/if branches that inspect .format
when making the change.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/views/LinkGrabberView/LinkGrabberView.tsx`:
- Around line 216-276: handleContainerFiles performs container import/resolve
outside the resolveLinks mutation state so overlapping drops can race; before
starting, guard against concurrent runs by checking the existing isResolving
flag used by resolveLinks and bail if true, and while processing set a shared
"resolving" state (reuse the resolveLinks mutation state if possible or set a
component-level isResolvingContainerImport boolean) to true, then set it back to
false in a finally block; ensure both the short-path resolveLinks({ urls }) call
and the chunked invoke("link_resolve", ...) flow respect this flag and that
applyResolvedBatch(merged) only runs when the flag is active, preventing a
second drop from overwriting resolvedLinks.
- Around line 141-173: The onError fallback in applyResolvedBatch can clobber
newer batches because it unconditionally calls setManyLinkStatuses for the
chunk; to fix, introduce a simple batch guard: add a local batchId (e.g.,
incrementing a ref or state like currentResolveBatchId) inside
applyResolvedBatch when it runs, capture that id in the closure passed to
checkLinksOnline, and in the onError callback only call
setManyLinkStatuses(chunk.map(...)) if the captured batchId ===
currentResolveBatchId; update applyResolvedBatch (and related helpers) to use
currentResolveBatchId when starting a batch so stale onError handlers cannot
overwrite statuses from newer batches.